package com.feicheng.service.impl;

import com.alibaba.fastjson.JSONException;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.feicheng.common.constant.Constant;
import com.feicheng.common.exception.SystemException;
import com.feicheng.common.message.LoginMessage;
import com.feicheng.common.result.ResultInfo;
import com.feicheng.persistence.entity.*;
import com.feicheng.persistence.service.*;
import com.feicheng.service.BaseService;
import com.feicheng.service.IFLoginService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import java.util.*;

@Service
public class FShopPasswordLoginServiceImpl extends BaseService implements IFLoginService {

    @Autowired
    IStoreUserService iUserService;

    @Autowired
    IStoreRoleService iRoleService;

    @Autowired
    IStorePermissionService iPermissionService;

    @Autowired
    IStoreUserRoleService iUserRoleService;

    @Autowired
    IStoreRolePermissionService iRolePermissionService;

    @Autowired
    IStoreUserInfoService iStoreUserInfoService;

    @Autowired
    IStoreService iStoreService;

    @Autowired
    LoginMessage loginMessage;

    @Override
    public ResultInfo login(String loginParams) {
        /* 取得登录所需的参数 账户 和  密码 ，转换出现问题时抛出异常，登录逻辑停止。*/
        JSONObject param = null;
        try {
            param = JSONObject.parseObject(loginParams);
        } catch (JSONException exception) {
            throw new SystemException(loginMessage.getE01());
        }

        // 取得登录所需的参数 账户
        String account = param.getString(Constant.ENTITY.USER.ACCOUNT);

        /* 账户取得失败时抛出异常，登录逻辑停止。 */
        if (!StringUtils.hasLength(account)) {
            throw new SystemException(loginMessage.getE02());
        }

        /* 密码取得失败时抛出异常，登录逻辑停止。 */
        String password = param.getString(Constant.ENTITY.USER.PASSWORD);
        if (!StringUtils.hasLength(password)) {
            throw new SystemException(loginMessage.getE03());
        }

        /* 构建查询条件，以账户为条件。 */
        QueryWrapper<StoreUser> qw = new QueryWrapper<StoreUser>();
        qw.eq(Constant.ENTITY.USER.ACCOUNT, account);

        /* 查询用户 */
        List<StoreUser> resultList = iUserService.list(qw);

        /* 找不到记录时，账户不存在。逻辑停止 */
        if (null == resultList || resultList.size() == 0) {
            throw new SystemException(loginMessage.getE04());
            /* 找到多条记录时，账户非法。逻辑停止 */
        } else if (resultList.size() > 1) {
            throw new SystemException(loginMessage.getE05());
        }

        /* 找且只找到一条时，登录逻辑继续。 */
        User currentUser = resultList.get(0);

        /* 密码校验不相等时，密码错误，登录逻辑停止。 */
        // TODO 密码加密
        if (!currentUser.getPassword().equals(password)) {
            throw new SystemException(loginMessage.getE06());
        }

        /* 构建返回结果，要包含用户信息，角色信息，权限信息。 */
        JSONObject currentUserInfo = new JSONObject();

        //返回的密码要设置为空，不可见
        currentUser.setPassword(null);

        // 将用户信息保存到返回结果中
        currentUserInfo.put(Constant.RESULT.USER.USER, currentUser);

        /* 构建角色ID查询，以用户ID为查询条件，查询角色ID集合 */
        QueryWrapper<StoreUserRole> qwUr = new QueryWrapper<StoreUserRole>();
        qwUr.eq(Constant.ENTITY.STORE_USER.USER_ID, currentUser.getUserId());

        // 查询角色ID集合
        List<StoreUserRole> userRoleList = iUserRoleService.list(qwUr);

        // 取得的角色ID保存到角色ID集合中
        Set<Integer> roleIds = new HashSet<Integer>();
        for (StoreUserRole ur : userRoleList) {
            roleIds.add(ur.getRoleId());
        }


        if (roleIds.size() > 0) {
            // 构建角色查询，以角色ID集合为查询条件。
            QueryWrapper<StoreRole> qwR = new QueryWrapper<StoreRole>();
            qwR.in(Constant.ENTITY.STORE_ROLE.ROLE_ID, roleIds);

            // 查询角色
            List<StoreRole> roleList = iRoleService.list(qwR);
            // 将角色信息保存到返回结果中
            currentUserInfo.put(Constant.RESULT.ROLE.ROLES, roleList);

            // 构建权限ID查询，以角色ID集合为查询条件
            QueryWrapper<StoreRolePermission> qwRp = new QueryWrapper<StoreRolePermission>();
            qwRp.in(Constant.ENTITY.ROLE.ROLE_ID, roleIds);

            // 查询权限ID集合
            List<StoreRolePermission> rolePermissionList = iRolePermissionService.list(qwRp);

            /* 将取得的权限ID保存到权限ID集合中 */
            Set<Integer> permissionIds = new HashSet<Integer>();
            for (RolePermission rp : rolePermissionList) {
                permissionIds.add(rp.getPermissionId());
            }

            if (permissionIds.size() > 0) {
                /* 构建权限查询，以权限ID集合为查询条件 */
                QueryWrapper<StorePermission> qwP = new QueryWrapper<StorePermission>();
                if (!permissionIds.isEmpty()) {
                    qwP.in(Constant.ENTITY.PERMISSION.PERMISSION_ID, permissionIds);
                }
                qwP.eq(Constant.ENTITY.PERMISSION.STATU, Boolean.TRUE);
                qwP.orderByAsc(Constant.ENTITY.PERMISSION.P_ID);

                // 查询权限
                List<StorePermission> permissionList = iPermissionService.list(qwP);

                /* 构建权限树 */
                List<StorePermission> pList = new ArrayList<StorePermission>();
                Map<Integer, StorePermission> permissionMap = new HashMap<Integer, StorePermission>();
                for (StorePermission p : permissionList) {

                    if (0 == p.getPId()) {
                        permissionMap.put(p.getPermissionId(), p);
                        pList.add(p);
                    } else {
                        List<Permission> subPList =
                                permissionMap.get(p.getPId()).getPermissions();
                        if (null == subPList) {
                            subPList = new ArrayList<Permission>();
                            permissionMap.get(p.getPId()).setPermissions(subPList);
                        }
                        subPList.add(p);
                    }
                }
                // 将权限信息保存到返回结果中
                currentUserInfo.put(Constant.RESULT.PERMISSION.PERMISSIONS, pList);
            }
        }



        QueryWrapper<StoreUserInfo> suisWrapper = new QueryWrapper<StoreUserInfo>();
        suisWrapper.eq(Constant.ENTITY.STORE_USER.USER_ID, currentUser.getUserId());

        List<StoreUserInfo> storeUserInfos = iStoreUserInfoService.list(suisWrapper);

        if (null == storeUserInfos) {
            throw new SystemException(loginMessage.getE07());
        } else if (storeUserInfos.size() > 1) {
            throw new SystemException(loginMessage.getE08());
        }

        Integer storeId = storeUserInfos.get(0).getStoreId();

        Store store = iStoreService.getById(storeId);

        currentUserInfo.put(Constant.RESULT.STORE.STORE, store);

        // 返回结果保存到session中
        super.setToken(Constant.RESULT.CURRENT, currentUserInfo);
        // 返回结果
        return ResultInfo.success(currentUserInfo);
    }
}
